import Decimal from 'decimal.js';

export async function wwjformula(datas) {
  return new Promise((resolve) => {
    try {
      // 检查输入是否为空
      if (!datas || datas.length === 0) {
        return resolve("");
      }

      // 如果输入是字符串，转换为数组格式
      let expressionArray;
      if (typeof datas === 'string') {
        expressionArray = parseStringExpression(datas);
      } else if (Array.isArray(datas)) {
        expressionArray = datas;
      } else {
        return resolve("");
      }

      // 递归处理括号
      const result = processExpression(expressionArray);
      
      // 处理结果
      if (!result || result === "") {
        return resolve("");
      }

      // 格式化结果
      const formattedResult = formatResult(result);
      resolve(formattedResult);
    } catch (error) {
      resolve("");
    }
  });
}

/**
 * 将字符串表达式解析为数组
 * @param {string} expression - 字符串表达式，如 "(1+2)*3"
 * @returns {Array} 表达式数组
 */
function parseStringExpression(expression) {
  const result = [];
  let currentNumber = '';
  
  for (let i = 0; i < expression.length; i++) {
    const char = expression[i];
    
    if (['+', '-', '*', '/', '(', ')'].includes(char)) {
      // 如果之前有数字，先添加数字
      if (currentNumber) {
        result.push(currentNumber);
        currentNumber = '';
      }
      
      // 特殊处理负号：如果-号在开头或者前面是操作符或左括号，则视为负数标记
      if (char === '-' && (result.length === 0 || 
          ['+', '-', '*', '/', '('].includes(result[result.length - 1]))) {
        // 这是一个负号，不是减号
        currentNumber = '-';
      } else {
        // 添加操作符
        result.push(char);
      }
    } else if (char >= '0' && char <= '9' || char === '.') {
      // 累积数字字符
      currentNumber += char;
    }
    // 忽略空格等其他字符
  }
  
  // 添加最后一个数字（如果有的话）
  if (currentNumber) {
    result.push(currentNumber);
  }
  
  return result;
}

/**
 * 递归处理表达式（包括括号）
 * @param {Array} datas - 表达式数组
 * @returns {string|Decimal} 计算结果
 */
function processExpression(datas) {
  // 查找最内层的括号
  let stack = [];
  let pairs = [];
  
  datas.forEach((item, index) => {
    if (item === "(") {
      stack.push(index);
    } else if (item === ")") {
      if (stack.length > 0) {
        const leftIndex = stack.pop();
        pairs.push({ left: leftIndex, right: index });
      }
    }
  });
  
  // 如果有括号，先计算最内层的括号
  if (pairs.length > 0) {
    // 找到最内层的括号（即右括号位置最小的一对）
    pairs.sort((a, b) => a.right - b.right);
    const innermost = pairs[0];
    
    // 计算括号内的表达式
    const subExpression = datas.slice(innermost.left + 1, innermost.right);
    const subResult = calculateExpression(subExpression);
    
    // 用结果替换括号部分
    const newDatas = [
      ...datas.slice(0, innermost.left),
      subResult,
      ...datas.slice(innermost.right + 1)
    ];
    
    // 递归处理剩余表达式
    return processExpression(newDatas);
  } else {
    // 没有括号，直接计算
    return calculateExpression(datas);
  }
}

/**
 * 计算简单表达式（不包含括号）
 * @param {Array} arr - 表达式数组
 * @returns {string|Decimal} 计算结果
 */
function calculateExpression(arr) {
  // 检查是否为空数组或只包含操作符
  if (!arr || arr.length === 0) {
    return "";
  }
  
  const operators = new Set(["+", "-", "*", "/", "(", ")"]);
  const isEmptyExpression = arr.every(item => item === "" || operators.has(item));
  if (isEmptyExpression) {
    return "";
  }

  try {
    // 复制数组以避免修改原数组
    let expression = [...arr];
    
    // 先处理乘除法（优先级高）
    for (let i = 1; i < expression.length; i += 2) {
      if (expression[i] === "*" || expression[i] === "/") {
        const left = new Decimal(expression[i - 1] !== undefined ? expression[i - 1] : 0);
        const right = new Decimal(expression[i + 1] !== undefined ? expression[i + 1] : 0);
        
        let result;
        if (expression[i] === "*") {
          result = left.mul(right);
        } else {
          if (right.isZero()) return "";
          result = left.div(right);
        }
        
        // 替换三个元素为一个结果
        expression.splice(i - 1, 3, result);
        i -= 2; // 调整索引
      }
    }
    
    // 再处理加减法
    let result = new Decimal(expression[0] !== undefined ? expression[0] : 0);
    for (let i = 1; i < expression.length; i += 2) {
      const operator = expression[i];
      const value = new Decimal(expression[i + 1] !== undefined ? expression[i + 1] : 0);
      
      switch (operator) {
        case "+":
          result = result.add(value);
          break;
        case "-":
          result = result.sub(value);
          break;
        default:
          throw new Error(`Unsupported operator: ${operator}`);
      }
    }
    
    return result;
  } catch (error) {
    return "";
  }
}

/**
 * 格式化计算结果
 * @param {string|Decimal} result - 计算结果
 * @returns {string} 格式化后的结果
 */
function formatResult(result) {
  try {
    // 转换为数字并保留6位小数
    const numResult = new Decimal(result);
    const fixedResult = numResult.toFixed(6);
    
    // 移除尾部多余的0
    const formatted = fixedResult.replace(/(?:\.0*|(\.\d+?)0+)$/, "$1");
    
    // 检查特殊值
    if (["NaN", "-Infinity", "Infinity"].includes(formatted)) {
      return "";
    }
    
    return formatted;
  } catch (error) {
    return "";
  }
}